1:1 Stable Pools

The 1:1 Stable Pools are designed to facilitate cross-chain liquidity transfers of stablecoins, ETH and other 1:1 traded assets across chains. The 1:1 Stable Pools uses the concept of a unified liquidity pool instead of separate pools for each chain pair.

These pools are governed by Delta Algorithm and provide instant guaranteed finality, high capital efficiency, and a seamless user experience.

Overview of the Delta Algorithm

The Delta Algorithm enables transactions using native assets without the need for intermediate or wrapped tokens. The Algorithm supports a unified liquidity pool across multiple chains, ensuring instant guaranteed finality and cross-chain composability.

Formulas and Liquidity Calculations

The Delta Algorithm is based on the concept of soft-partitioned liquidity, where each liquidity pool is conditionally divided among all connected chains.

Let:

• $a_s$ - current size of the liquidity pool on the local chain S
• $b_{s,d}$ - liquidity balance available for transfers from chain S to chain D
• $w_{s,d}$ - weight that describes the portion of liquidity allocated for transfers between chains S and D

The goal of the Algorithm is to maintain the following relationship:

$$b_{s,d} ≈ a_s × w_{s,d}$$

When a user initiates a transfer of $t$ units of liquidity from chain S to chain D, the Algorithm checks whether there are enough funds on chain D to complete the transfer. If the balance is insufficient, the transfer is rejected i.e., If $b_{s,d} <br t$, then the transfer is rejected.

If the balance is sufficient, the transfer is accepted, and the liquidity is updated:

$$a_s ← a_s + t$$

$$b_{s,d} ← b_{s,d} - t$$

Next, the Delta Algorithm redistributes liquidity to restore the balance between connected chains using the following steps:

1. The difference ($diff_{s,x}$) between the current balance and the desired balance is calculated:

$$diff_{s,x} = max(0, a_s × w_{s,x} - (lkb_{x,s} + c_{s,x}))$$

2. This difference is distributed among all connected chains proportionally to their weights.

If the total amount of redistributed liquidity is less than the current transaction ($t$), the remaining amount ($t'$) is also distributed proportionally to the weights:

$$c_{s,x} ← c_{s,x} + diff_{s,x} + t' × w_{s,x}$$

Example 1: Transfer from Chain X to Chain Y

Let:

• $a_X = 100$
• $w_{X,Y} = 0.5$
• user initiates a transfer of $t = 40$ from chain X to chain Y

1. The balance on Y is checked: $b_{X,Y} = 60$, which is greater than 40, so the transfer is not rejected.

2. The balance on X is updated:

$$a_X ← 100 + 40 = 140$$

$$b_{X,Y} ← 60 - 40 = 20$$

3. The liquidity redistribution is calculated:

Let:

• $lkb_{Y,X} = 50$
• $c_{X,Y} = 20$

Since the weights are equal, the remainder is evenly split:

$$c_{X,Y} ← 20 + 20 = 40$$

Example 2: Transfer from Chain Y to Chain Z

1. The balance on Z is checked: $b_{Y,Z} = 40$, which is greater than 30, so the transfer is not rejected.

2. The balance on Y is updated:

$$a_Y ← 100 + 30 = 130$$

$$b_{Y,Z} ← 40 - 30 = 10$$

3. The liquidity redistribution is calculated:

$$c_{Y,X} = 60 × 0.6 - 20 = 16$$

$$c_{Y,Z} = 60 × 0.4 - 10 = 14$$

Thus, the total amount of liquidity that is redistributed is 30, and these amounts are recorded as credits for future transfers.

Cross-Chain Composability

The Delta Algorithm allows cross-chain operations within a single transaction. For example, a user can:

• Exchange stablecoins for ETH on chain A
• Transfer ETH to chain B using the Delta Algorithm
• Immediately after the transfer, exchange ETH for USDC on chain B

All these operations can be performed within a single transaction, significantly simplifying the process for the user.